<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>
<script>
    // '' + [1, [2], [[4]], [[[6]]] ]  字符串可以强行将数组打平并变成字符串
    // 要求实现一个flatten 函数， 要求第二个参数可以课可以指定打平等级
    var a = [1, [2], [[4]], [[[6]]] ]

    // 判断一个数组最深的嵌套层级
    const hasLevels = (arr, level = 1) => {
      const result = []
      arr.forEach(item => {
        if (Array.isArray(item)) {
          result.push(...item) // 去掉一层
        }
      })
      if (!result.length) return level
      return hasLevels(result, level +1)
    }



    // console.log('数组的层级=', hasLevels(a))


    // 引入了额外的变量，有改进空间
    // function flatten (arr, level = 1) {
    //   if (!Array.isArray(arr)) throw new Error('第一个参数必须是合法的数组')
    //   let result = []
    //
    //   const fn = arr => {
    //     arr.forEach(item => {
    //       if (!Array.isArray(item)) {
    //         result.push(item)
    //       } else { // 判断当前元素嵌套的层级
    //         result.push(...item)
    //       }
    //     })
    //   }
    //   flatten.curLevel ? (flatten.curLevel = flatten.curLevel + 1) : (flatten.curLevel = 1)
    //   fn(arr)
    //   // 判断result
    //   if (flatten.curLevel < level) {
    //     return flatten(result, level)
    //   } else {
    //     flatten.curLevel = null // 需要对自身进行重置
    //     return result
    //   }
    // }


    // console.log('打平一层数组：')
    // console.log(flatten(a))
    // console.log('打平二层数组：')
    // console.log(flatten(a, 2))
    // console.log('打平三层数组：')
    // console.log(flatten(a, 3))
    // console.log('打平四层数组：')
    // console.log(flatten(a, 4))

    // 这种方式比较好，不需要额外的变量同时还能减少递归的次数，，比较号
    // function flatten2 (arr, level = 1) {
    //   if (!Array.isArray(arr)) throw new Error('第一个参数必须是合法的数组')
    //   let result = []
    //   arr.forEach(item => {
    //     if (Array.isArray(item)) {
    //       result.push(...item)
    //     } else {
    //       result.push(item)
    //     }
    //   })
    //   level--
    //   const hasArr = result.find(item  => Array.isArray(item))
    //   if (level === 0 || !hasArr) {
    //     return result
    //   } else {
    //     flatten2 (arr, level)
    //   }
    // }

    // console.log('打平一层数组：')
    // console.log(flatten2(a))
    // console.log('打平二层数组：')
    // console.log(flatten(a, 2))
    // console.log('打平三层数组：')
    // console.log(flatten(a, 3))
    // console.log('打平四层数组：')
    // console.log(flatten(a, 4))




    // 题目2 const event = new EventEmitter();

    // 绑定事件
    //
    // event.on(name, callback);
    //
    // 取消绑定
    //
    // event.off(name);
    //
    // 触发事件
    //
    // event.emit(name, data);


    // function  EventEmitter () {
    //   this.events = {}
    //   this.on = function (name, callback) {
    //     this.events[name] = callback.bind(this)
    //   }
    //   this.off = function (name, callback) {
    //     this.events[name]  = null
    //   }
    //   this.emit = function (name, data) {
    //      if (!this.events[name]) {
    //        return new Error(`不存在绑定的事件${name}`)
    //      }
    //      if (this.events[name]  instanceof Function) {
    //        this.events[name](data)
    //      }
    //   }
    // }
    //
    // var event1 = new EventEmitter()
    // event1.on('print', function(data){
    //    console.log('print------' + data)
    // })
    // event1.emit('print',  3333333)
    // event1.off('print')
    // event1.emit('print',  44333333)


    // 反转字符串
    // var a = '1267hgo0'
    // 方式1
    const reverseStr = str => {
      let result = ''
      for(let i = str.length - 1; i >=0; i--) {
        result = result + str[i]
      }
      return result
    }
    // 转数组然后翻转数组即可
    // 现在想使用reduce 实现 ----从多个值最后得到一个值，有类似合并的过程都可以考虑reduce 函数
    const reverseStr2 = str => {
      let strArr = Array.from(str)
      return strArr.reduce(function (prev, cur, currentIndex) {
        prev = cur + prev
        return prev
      }, '')
    }

    // console.log('反转结果---' + reverseStr2(a))

    // 回文数，就是正反过来数目是一样的，所以可以考虑先翻转然后对比每一个位置一样即可，但是这样麻烦点，直接从定义入手
    // 一次循环，同时前后都取值，然后判断是不是一致的即可，当index 相等或者相加的时候，验证结束
    // const validateHuiWen = (str) => {
    //   str = str + ''
    //   const len = str.length
    //   let index = Math.floor(len / 2) // 计算循环的位置
    //   let result = 0
    //
    //   for (let i = 0; i <= index; i ++) {
    //     if (str[i] === str[len- i - 1]){
    //       result = result + 1
    //     }
    //   }
    //
    //   return result === (index + 1)
    // }

    // console.log('是否是回文字符串' + validateHuiWen('2132'))


    // 输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
    // 输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
    // 首先得确认字母异位词  1 位数相同 2 包含所有的字母
     var strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
    const classfyArrZy = (arr) => {

      const newArr = arr.map(item => {
        return item.split('').sort().join('')
      })
      const newArrMap = {}
      newArr.forEach((item, index) => {
        newArrMap[item] ? (newArrMap[item] = newArrMap[item] + '-' + index) : (newArrMap[item] = String(index))
      })

      const result = Object.values(newArrMap).map(item => {
        return item.split('-').map(j => strs[j])
      })
      return result
    }

    // console.log('结果是---')
    // console.log(classfyArrZy(strs))
    //   ['c', 'd', 'f', 'g', 'a'].sort(function (xx, xt) {
    //     console.log('a='+ xx, 'b=' + xt)
    //      return xt - xx
    //   })


    // 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
    // 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。



    // 示例 1：
    //
    // 输入：nums = [100,4,200,1,3,2]
    //     输出：4
    //     解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
    // 示例 2：
    //
    // 输入：nums = [0,3,7,2,5,8,4,6,0,1]
    //     输出：9


</script>
</html>
